import 'dart:io';
import 'package:get/get.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:signature/signature.dart';
import 'package:flutter_easyloading/flutter_easyloading.dart';
import '../../../common/api/index.dart';
import '../../../common/models/index.dart';
import '../../../common/mixins/user_profile_mixin.dart';
import '../../../common/utils/index.dart';

class ShnebaoAssessmentDetialController extends GetxController with UserProfileMixin {
  ShnebaoAssessmentDetialController();

  // 🔥 状态管理
  final isLoading = true.obs;
  final errorMessage = ''.obs;
  final Rx<ProjectModel?> project = Rx<ProjectModel?>(null);
  
  // 👥 专家列表状态管理
  final isLoadingExperts = false.obs;
  final expertErrorMessage = ''.obs;
  final RxList<ProjectExpert> projectExperts = <ProjectExpert>[].obs;
  
  // 📊 项目步骤信息状态管理
  final isLoadingSteps = false.obs;
  final stepErrorMessage = ''.obs;
  final RxMap<String, dynamic> projectSteps = <String, dynamic>{}.obs;
  
  
  // 📝 评审相关状态管理
  final reviewOpinion = ''.obs;           // 审核意见
  final isUploading = false.obs;          // 正在上传状态
  final uploadErrorMessage = ''.obs;      // 上传错误信息
  final hasSignature = false.obs;         // 是否已有签名
  final signatureUploaded = false.obs;    // 签名是否已上传成功
  final isLeader = false.obs;             // 是否是组长
  final isCheckingLastExpert = false.obs; // 是否正在检查最后专家
  
  // 🗳️ 投票选举相关状态管理
  final isLoadingVote = false.obs;        // 是否正在加载投票信息
  final hasVoted = false.obs;             // 当前专家是否已投票
  final expertNum = 0.obs;                // 专家总数
  final votedNum = 0.obs;                 // 已投票专家数
  final electedLeaderId = 0.obs;          // 当选组长的专家ID
  final selectedExpertId = 0.obs;         // 选中的专家ID（用于投票）
  final voteErrorMessage = ''.obs;        // 投票错误信息
  final voteSheetType = ''.obs;           // 投票弹出框类型: 'election', 'progress', 'result', ''
  
  // 🖊️ 手写签名控制器
  late SignatureController signatureController;
  
  // 项目ID
  int? projectId;

  // 🔥 获取当前登录专家的ID（从UserProfileMixin）
  int get currentExpertId {
    final expertIdStr = expertId; // 从UserProfileMixin获取String类型的expertId
    final parsedId = int.tryParse(expertIdStr);
    
    if (parsedId == null || parsedId <= 0) {
      debugPrint('⚠️ 专家ID无效: $expertIdStr，使用默认值1');
      return 1; // 如果解析失败，使用默认值
    }
    
    debugPrint('✅ 使用专家ID: $parsedId');
    return parsedId;
  }

  _initData() {
    _initializeParameters();
    _initializeData(); // 在参数初始化后再初始化数据
    _initializeSignature(); // 初始化签名控制器
    update(["shnebao_assessment_detial"]);
  }

  /// 初始化签名控制器
  void _initializeSignature() {
    signatureController = SignatureController(
      penStrokeWidth: 2,
      penColor: Colors.black,
      exportBackgroundColor: Colors.white,
    );
    
    // 监听签名变化
    signatureController.addListener(() {
      hasSignature.value = signatureController.isNotEmpty;
    });
  }

  /// 统一的参数初始化方法
  void _initializeParameters() {
    try {
      final args = Get.arguments;
      
      if (args != null && args is Map<String, dynamic>) {
        projectId = args['projectId'] is int ? args['projectId'] as int : 
                   int.tryParse(args['projectId']?.toString() ?? '0');
        
        debugPrint('📋 申报评估详情页 - 参数初始化成功: projectId=$projectId');
      } else {
        _setDefaultParameters();
      }
    } catch (e) {
      debugPrint('❌ 申报评估详情页 - 参数初始化失败: $e');
      _setDefaultParameters();
    }
  }

  /// 设置默认参数
  void _setDefaultParameters() {
    projectId = null;
    debugPrint('⚠️ 申报评估详情页 - 使用默认参数');
  }

  /// 在参数初始化后进行数据初始化
  void _initializeData() {
    if (projectId != null && projectId! > 0) {
      loadProjectDetail();
      loadProjectExperts();
      loadProjectSteps(); // 加载项目步骤信息
      _loadLeaderInfo(); // 加载组长信息
    } else {
      errorMessage.value = projectId == null ? '未找到项目ID' : '项目ID无效';
      isLoading.value = false;
      debugPrint('❌ 申报评估详情页 - 项目ID无效，无法加载数据');
    }
  }
  
  /// 加载组长信息（获取当选组长）
  Future<void> _loadLeaderInfo() async {
    if (projectId == null) return;
    
    try {
      debugPrint('🔍 加载组长信息...');
      
      // 获取得票最多的专家ID
      final leaderId = await UserApi.getMostVotesExpertId(
        projectId: projectId!,
        voteFlag: 0, // 0-评审
      );
      
      if (leaderId > 0) {
        // 判断当前用户是否是组长
        isLeader.value = (leaderId == currentExpertId);
        debugPrint('✅ 组长ID: $leaderId, 当前用户${isLeader.value ? "是" : "不是"}组长');
      } else {
        debugPrint('⚠️ 暂未选出组长');
        isLeader.value = false;
      }
      
    } catch (e) {
      debugPrint('❌ 加载组长信息失败: $e');
      isLeader.value = false;
    }
  }

  /// 加载项目详细信息
  Future<void> loadProjectDetail() async {
    if (projectId == null) return;
    
    try {
      debugPrint('🔄 申报评估详情页 - 开始加载项目详细信息');
      isLoading.value = true;
      errorMessage.value = '';
      
      final projectDetail = await ProjectApi.getProjectInfo(projectId: projectId!);
      project.value = projectDetail;
      
      debugPrint('✅ 申报评估详情页 - 加载项目详细信息成功: ${projectDetail.projectName}');
      
    } catch (e) {
      debugPrint('❌ 申报评估详情页 - 加载项目详细信息失败: $e');
      errorMessage.value = e.toString().replaceAll('Exception: ', '');
    } finally {
      isLoading.value = false;
    }
  }

  /// 加载项目专家列表
  Future<void> loadProjectExperts() async {
    if (projectId == null) return;
    
    try {
      debugPrint('👥 申报评估详情页 - 开始加载项目专家列表');
      isLoadingExperts.value = true;
      expertErrorMessage.value = '';
      
      // 申报评估页面显示评审人专家列表 (flag = 0)
      final experts = await ProjectApi.getProjectExpertList(
        projectId: projectId!,
        flag: 0, // 0-评审人专家列表
      );
      
      projectExperts.value = experts;
      debugPrint('✅ 申报评估详情页 - 加载项目专家列表成功，共 ${experts.length} 个专家');
      
      // 打印每个专家的详细信息，特别是 reviewStatus
      if (experts.isNotEmpty) {
        debugPrint('📋 专家列表详情：');
        for (var i = 0; i < experts.length; i++) {
          final expert = experts[i];
          debugPrint('  ${i + 1}. 专家ID: ${expert.expertId}, 姓名: ${expert.expertName}');
          debugPrint('     reviewStatus: ${expert.reviewStatus} (0=未评审, 1=已评审)');
          debugPrint('     reviewSign: ${expert.reviewSign ?? "无签名"}');
          debugPrint('     reviewNote: ${expert.reviewNote ?? "无意见"}');
          
          // 特别标记当前登录专家
          if (expert.expertId == currentExpertId) {
            debugPrint('     👉 这是当前登录专家！');
          }
        }
      }
      
    } catch (e) {
      debugPrint('❌ 申报评估详情页 - 加载项目专家列表失败: $e');
      expertErrorMessage.value = e.toString().replaceAll('Exception: ', '');
    } finally {
      isLoadingExperts.value = false;
    }
  }


  /// 刷新项目详细信息
  Future<void> refreshProjectDetail() async {
    await Future.wait([
      loadProjectDetail(),
      loadProjectExperts(),
      loadProjectSteps(),
    ]);
  }

  /// 单独刷新专家列表
  Future<void> refreshProjectExperts() async {
    await loadProjectExperts();
  }

  /// 加载项目步骤信息（获取全部步骤 2-6）
  Future<void> loadProjectSteps() async {
    if (projectId == null) return;
    
    try {
      debugPrint('📊 申报评估详情页 - 开始加载项目步骤信息');
      isLoadingSteps.value = true;
      stepErrorMessage.value = '';
      
      // 调用API获取全部步骤信息（step=8返回所有步骤的原始数据）
      final stepsData = await ProjectApi.getProjectStepInfo(
        projectId: projectId!,
        step: 8, // 8-获取全部步骤的原始数据（purchaseJson, softwareJson, implementationJson, estimationJson, cloudJson, budgetJson）
      );
      
      projectSteps.value = stepsData;
      debugPrint('✅ 申报评估详情页 - 加载项目步骤信息成功');
      debugPrint('📋 步骤数据: ${stepsData.keys}');
      
    } catch (e) {
      debugPrint('❌ 申报评估详情页 - 加载项目步骤信息失败: $e');
      stepErrorMessage.value = e.toString().replaceAll('Exception: ', '');
    } finally {
      isLoadingSteps.value = false;
    }
  }

  /// 单独刷新项目步骤信息
  Future<void> refreshProjectSteps() async {
    await loadProjectSteps();
  }


  /// 查看申报文件
  void onViewDocuments() {
    try {
      debugPrint('📄 申报评估详情页 - 查看申报文件');
      
      if (project.value == null) {
        LoadingUtil.info('项目信息未加载完成，请稍后再试');
        return;
      }
      
      // TODO: 实现查看申报文件的逻辑
      // 这里可以跳转到文件查看页面或者打开文件查看器
      LoadingUtil.info('正在打开申报文件...');
      
      debugPrint('✅ 申报评估详情页 - 查看申报文件操作完成');
      
    } catch (e) {
      debugPrint('❌ 申报评估详情页 - 查看申报文件失败: $e');
      LoadingUtil.error('查看申报文件失败，请重试');
    }
  }

  /// 📝 开始评审（投票已在列表页完成，直接进入评审）
  void onStartReview() {
    try {
      debugPrint('🚀 申报评估详情页 - 开始评审');
      
      if (project.value == null) {
        LoadingUtil.info('项目信息未加载完成，请稍后再试');
        return;
      }
      
      // 直接进入评审
      enterReview();
      
    } catch (e) {
      debugPrint('❌ 申报评估详情页 - 开始评审失败: $e');
      LoadingUtil.error('开始评审失败，请重试');
    }
  }

  /// 检查投票状态并设置要显示的弹出框类型
  Future<void> checkVoteStatusAndShow() async {
    if (projectId == null) return;
    
    try {
      isLoadingVote.value = true;
      voteErrorMessage.value = '';
      voteSheetType.value = '';
      
      debugPrint('🔍 检查投票状态...');
      
      // 1. 检查当前专家是否已投票
      final voted = await UserApi.checkVoted(
        projectId: projectId!,
        voterId: currentExpertId,
        voteFlag: 0, // 0-评审
      );
      hasVoted.value = voted;
      
      // 2. 获取投票统计信息
      final voteStats = await UserApi.getVoteNum(
        projectId: projectId!,
        voteFlag: 0, // 0-评审
      );
      expertNum.value = voteStats['expertNum'] ?? 0;
      votedNum.value = voteStats['votedNum'] ?? 0;
      
      debugPrint('📊 投票状态: 已投票=$voted, 专家总数=${expertNum.value}, 已投票数=${votedNum.value}');
      
      // 3. 判断投票是否全部完成
      final allVoted = votedNum.value >= expertNum.value && expertNum.value > 0;
      
      if (allVoted) {
        // 投票已完成，获取当选组长
        final leaderId = await UserApi.getMostVotesExpertId(
          projectId: projectId!,
          voteFlag: 0, // 0-评审
        );
        electedLeaderId.value = leaderId;
        
        // 判断当前用户是否是组长
        isLeader.value = (leaderId == currentExpertId);
        
        debugPrint('🏆 投票已完成，当选组长ID: $leaderId, 当前用户${isLeader.value ? "是" : "不是"}组长');
      }
      
      // 4. 根据状态设置弹出框类型
      if (!voted) {
        // 未投票：显示投票选举界面
        debugPrint('📋 设置显示投票选举界面');
        voteSheetType.value = 'election';
      } else if (!allVoted) {
        // 已投票但未全部完成：显示投票进度
        debugPrint('📊 设置显示投票进度');
        voteSheetType.value = 'progress';
      } else {
        // 投票已全部完成：显示选举结果
        debugPrint('🎉 设置显示选举结果');
        voteSheetType.value = 'result';
      }
      
    } catch (e) {
      debugPrint('❌ 检查投票状态失败: $e');
      voteErrorMessage.value = e.toString().replaceAll('Exception: ', '');
      LoadingUtil.error('检查投票状态失败，请重试');
    } finally {
      isLoadingVote.value = false;
    }
  }
  
  /// 提交投票
  Future<void> submitVote() async {
    if (projectId == null) return;
    
    if (selectedExpertId.value <= 0) {
      LoadingUtil.info('请选择要投票的专家');
      return;
    }
    
    try {
      LoadingUtil.show('正在提交投票...');
      
      debugPrint('🗳️ 提交投票: 项目ID=$projectId, 选举人=$currentExpertId, 被选举人=${selectedExpertId.value}');
      
      final success = await UserApi.voteTeamLeader(
        projectId: projectId!,
        voterId: currentExpertId,
        beVotedId: selectedExpertId.value,
        voteFlag: 0, // 0-评审
      );
      
      if (success) {
        debugPrint('✅ 投票成功');
        hasVoted.value = true;
        
        // 关闭当前弹出框
        Get.back();
        
        LoadingUtil.success('投票成功');
        
        // 延迟后重新检查状态并显示进度
        await Future.delayed(const Duration(milliseconds: 500));
        await checkVoteStatusAndShow();
      }
      
    } catch (e) {
      debugPrint('❌ 投票失败: $e');
      LoadingUtil.error('投票失败：${e.toString().replaceAll('Exception: ', '')}');
    }
  }
  
  /// 刷新投票状态
  Future<void> refreshVoteStatus() async {
    if (projectId == null) return;
    
    try {
      isLoadingVote.value = true;
      
      // 1. 检查当前专家是否已投票
      final voted = await UserApi.checkVoted(
        projectId: projectId!,
        voterId: currentExpertId,
        voteFlag: 0,
      );
      hasVoted.value = voted;
      
      // 2. 获取投票统计信息
      final voteStats = await UserApi.getVoteNum(
        projectId: projectId!,
        voteFlag: 0,
      );
      expertNum.value = voteStats['expertNum'] ?? 0;
      votedNum.value = voteStats['votedNum'] ?? 0;
      
      debugPrint('🔄 投票状态已刷新: 已投票=$voted, ${votedNum.value}/${expertNum.value}');
      
      // 3. 如果投票已完成，获取当选组长
      if (votedNum.value >= expertNum.value && expertNum.value > 0) {
        final leaderId = await UserApi.getMostVotesExpertId(
          projectId: projectId!,
          voteFlag: 0,
        );
        electedLeaderId.value = leaderId;
        isLeader.value = (leaderId == currentExpertId);
      }
      
    } catch (e) {
      debugPrint('❌ 刷新投票状态失败: $e');
    } finally {
      isLoadingVote.value = false;
    }
  }
  
  /// 进入评审详情（投票已在列表页完成）
  void enterReview() {
    try {
      debugPrint('📝 进入评审详情');
      
      // 重置评审状态
      _resetReviewState();
      
      // 显示评审底部弹出框
      _showReviewBottomSheet();
      
    } catch (e) {
      debugPrint('❌ 进入评审失败: $e');
      LoadingUtil.error('进入评审失败，请重试');
    }
  }

  /// 重置评审状态
  void _resetReviewState() {
    reviewOpinion.value = '';
    signatureController.clear();
    hasSignature.value = false;
    signatureUploaded.value = false;
    isUploading.value = false;
    uploadErrorMessage.value = '';
    // isLeader 由投票结果决定，不在这里重置
    isCheckingLastExpert.value = false;
  }
  

  /// 显示评审底部弹出框
  void _showReviewBottomSheet() {
    Get.bottomSheet(
      _ReviewBottomSheet(controller: this),
      isScrollControlled: true,
      isDismissible: true,
      enableDrag: true,
    );
  }

  /// 清除手写签名
  void onClearSignature() {
    try {
      debugPrint('🗑️ 申报评估详情页 - 清除手写签名');
      signatureController.clear();
      hasSignature.value = false;
      signatureUploaded.value = false; // 清除签名时也清除上传状态
    } catch (e) {
      debugPrint('❌ 申报评估详情页 - 清除签名异常: $e');
    }
  }

  /// 将签名转换为图片文件
  Future<File?> _convertSignatureToImageFile() async {
    try {
      debugPrint('🖼️ 申报评估详情页 - 开始转换签名为图片');
      
      if (signatureController.isEmpty) {
        debugPrint('⚠️ 签名为空，无法转换');
        return null;
      }
      
      // 获取签名的图片数据
      final Uint8List? signatureBytes = await signatureController.toPngBytes();
      if (signatureBytes == null) {
        debugPrint('❌ 签名转换失败');
        return null;
      }
      
      // 创建临时文件
      final String timestamp = DateTime.now().millisecondsSinceEpoch.toString();
      final String fileName = 'signature_$timestamp.png';
      
      // 使用系统临时目录
      final String tempPath = Directory.systemTemp.path;
      final String filePath = '$tempPath/$fileName';
      
      // 写入文件
      final File signatureFile = File(filePath);
      await signatureFile.writeAsBytes(signatureBytes);
      
      debugPrint('✅ 签名转换成功: $filePath');
      debugPrint('📄 文件大小: ${signatureBytes.length} bytes');
      
      return signatureFile;
      
    } catch (e) {
      debugPrint('❌ 签名转换异常: $e');
      return null;
    }
  }

  /// 上传签名图片（内部方法，由评审通过/拒绝调用）
  /// [reviewStatus] 评审状态：1-未通过，2-通过
  Future<bool> _uploadSignatureWithStatus(int reviewStatus) async {
    try {
      debugPrint('📷 申报评估详情页 - 开始上传签名，reviewStatus=$reviewStatus');
      
      if (!hasSignature.value || signatureController.isEmpty) {
        LoadingUtil.info('请先完成手写签名');
        return false;
      }
      
      debugPrint('🔄 申报评估详情页 - 开始转换并上传签名');
      
      // 将签名转换为图片文件
      final signatureFile = await _convertSignatureToImageFile();
      if (signatureFile == null) {
        uploadErrorMessage.value = '签名转换失败，请重新签名';
        LoadingUtil.error('签名转换失败，请重新签名');
        return false;
      }
      
      // 调用上传签名API（上传图片并提交评审状态）
      final uploadResult = await ProjectApi.uploadSignature(
        expertId: currentExpertId,
        projectId: projectId!,
        flag: 0, // 0-评审人签名
        file: signatureFile,
        reviewStatus: reviewStatus, // 传递评审状态
      );
        
        // 清理临时文件
        try {
          await signatureFile.delete();
          debugPrint('🗑️ 临时签名文件已清理');
        } catch (e) {
          debugPrint('⚠️ 清理临时文件失败: $e');
        }
        
      if (uploadResult.success) {
        debugPrint('✅ 申报评估详情页 - 签名上传成功: ${uploadResult.url}');
        signatureUploaded.value = true;
        return true;
      } else {
        debugPrint('❌ 申报评估详情页 - 签名上传失败: ${uploadResult.errorMessage}');
        uploadErrorMessage.value = uploadResult.errorMessage ?? '上传失败';
        LoadingUtil.error(uploadResult.errorMessage ?? '签名上传失败，请重试');
        return false;
      }
      
    } catch (e) {
      debugPrint('❌ 申报评估详情页 - 上传签名异常: $e');
      uploadErrorMessage.value = '网络错误，请重试';
      LoadingUtil.error('签名上传失败，请检查网络后重试');
      return false;
    }
  }

  /// 取消评审 - 关闭弹出框
  void onCancelReview() {
    debugPrint('❌ 申报评估详情页 - 取消评审');
    Get.back();
  }

  /// 验证是否可以提交评审
  bool canSubmitReview() {
    // 🔥 区分组长和组员的验证逻辑
    
    // 组长：需要填写评审意见 + 签名
    if (isLeader.value) {
      // 验证评审意见
      if (reviewOpinion.value.trim().isEmpty) {
        LoadingUtil.info('请填写评审意见');
        return false;
      }
    }
    // 组员：只需要签名（评审意见由组长统一填写）
    
    // 验证签名是否已绘制（不再要求提前上传）
    if (!hasSignature.value || signatureController.isEmpty) {
      LoadingUtil.info('请先完成手写签名');
      return false;
    }
    
    if (projectId == null) {
      LoadingUtil.info('项目ID为空');
      return false;
    }
    
    return true;
  }


  /// 评审通过
  Future<void> onReviewApprove() async {
    try {
      debugPrint('✅ 申报评估详情页 - 评审通过');
      
      // 验证是否可以提交
      if (!canSubmitReview()) {
        return;
      }
      
      // 检查项目信息是否存在
      if (project.value == null) {
        LoadingUtil.info('项目信息未加载，无法提交');
        return;
      }
      
      // 显示加载提示
      LoadingUtil.show('正在提交评审结果...');
      
      // 🔥 第一步：上传签名图片（传递reviewStatus=2表示通过）
      debugPrint('📷 第一步：上传签名图片');
      final uploadSuccess = await _uploadSignatureWithStatus(2); // 2-通过
      if (!uploadSuccess) {
        EasyLoading.dismiss();
        return;
      }
      
      // 打印详细参数
      final isLeaderValue = isLeader.value ? 1 : 0;
      final currentProjectStatus = project.value!.status ?? 2; // 使用项目实际状态，如果为空则默认2
      
      debugPrint('📝 第二步：调用 expertReview API - 评审通过');
      debugPrint('📝 专家ID: $currentExpertId');
      debugPrint('📝 项目ID: $projectId');
      debugPrint('📝 项目当前状态: $currentProjectStatus (从项目信息获取)');
      debugPrint('📝 评审状态 reviewStatus: 2 (通过)');
      debugPrint('📝 评审意见 note: ${reviewOpinion.value.trim()}');
      debugPrint('📝 是否组长 isLeader: $isLeaderValue');
      
      // 🔥 第二步：调用专家评审API - 评审通过（使用填写的评审意见）
      final success = await UserApi.expertReview(
        expertId: currentExpertId,
        projectId: projectId!,
        projectStatus: currentProjectStatus, // 使用项目实际状态
        reviewStatus: 2, // 2-通过
        note: reviewOpinion.value.trim(), // 使用填写的评审意见
        isLeader: isLeaderValue, // 使用用户选择的组长状态
      );
      
      if (success) {
        debugPrint('✅ 申报评估详情页 - 评审通过处理完成');
        
        // 🔥 关键修复：先关闭加载框，再关闭底部弹出框
        EasyLoading.dismiss();
        debugPrint('🔄 加载框已关闭');
        
        // 稍微延迟确保加载框完全消失
        await Future.delayed(const Duration(milliseconds: 100));
        
        // 关闭底部弹出框
        Get.back();
        debugPrint('🚪 评审弹出框已关闭');
        
        // 稍微延迟一下再刷新数据，确保弹出框完全关闭
        await Future.delayed(const Duration(milliseconds: 300));
        
        // 刷新项目信息和专家列表
        await refreshProjectDetail();
        
        // 显示成功提示
        LoadingUtil.success('项目评审已通过');
      }
      
    } catch (e) {
      debugPrint('❌ 申报评估详情页 - 评审通过失败: $e');
      LoadingUtil.error('评审通过操作失败：${e.toString().replaceAll('Exception: ', '')}');
    }
  }

  /// 评审拒绝
  Future<void> onReviewReject() async {
    try {
      debugPrint('❌ 申报评估详情页 - 评审拒绝');
      
      // 验证是否可以提交
      if (!canSubmitReview()) {
        return;
      }
      
      // 检查项目信息是否存在
      if (project.value == null) {
        LoadingUtil.info('项目信息未加载，无法提交');
        return;
      }
      
      // 显示加载提示
      LoadingUtil.show('正在提交评审结果...');
      
      // 🔥 第一步：上传签名图片（传递reviewStatus=1表示未通过）
      debugPrint('📷 第一步：上传签名图片');
      final uploadSuccess = await _uploadSignatureWithStatus(1); // 1-未通过
      if (!uploadSuccess) {
        EasyLoading.dismiss();
        return;
      }
      
      // 打印详细参数
      final isLeaderValue = isLeader.value ? 1 : 0;
      final currentProjectStatus = project.value!.status ?? 2; // 使用项目实际状态，如果为空则默认2
      
      debugPrint('📝 第二步：调用 expertReview API - 评审拒绝');
      debugPrint('📝 专家ID: $currentExpertId');
      debugPrint('📝 项目ID: $projectId');
      debugPrint('📝 项目当前状态: $currentProjectStatus (从项目信息获取)');
      debugPrint('📝 评审状态 reviewStatus: 1 (未通过)');
      debugPrint('📝 评审意见 note: ${reviewOpinion.value.trim()}');
      debugPrint('📝 是否组长 isLeader: $isLeaderValue');
      
      // 🔥 第二步：调用专家评审API - 评审拒绝（使用填写的评审意见）
      final success = await UserApi.expertReview(
        expertId: currentExpertId,
        projectId: projectId!,
        projectStatus: currentProjectStatus, // 使用项目实际状态
        reviewStatus: 1, // 1-未通过
        note: reviewOpinion.value.trim(), // 使用填写的评审意见
        isLeader: isLeaderValue, // 使用用户选择的组长状态
      );
      
      if (success) {
        debugPrint('✅ 申报评估详情页 - 评审拒绝处理完成');
        
        // 🔥 关键修复：先关闭加载框，再关闭底部弹出框
        EasyLoading.dismiss();
        debugPrint('🔄 加载框已关闭');
        
        // 稍微延迟确保加载框完全消失
        await Future.delayed(const Duration(milliseconds: 100));
        
        // 关闭底部弹出框
        Get.back();
        debugPrint('🚪 评审弹出框已关闭');
        
        // 稍微延迟一下再刷新数据，确保弹出框完全关闭
        await Future.delayed(const Duration(milliseconds: 300));
        
        // 刷新项目信息和专家列表
        await refreshProjectDetail();
        
        // 显示提示
        LoadingUtil.success('项目评审已拒绝');
      }
      
    } catch (e) {
      debugPrint('❌ 申报评估详情页 - 评审拒绝失败: $e');
      LoadingUtil.error('评审拒绝操作失败：${e.toString().replaceAll('Exception: ', '')}');
    }
  }

  void onTap() {}

  @override
  void onReady() {
    super.onReady();
    _initData();
  }

  @override
  void onClose() {
    // 先关闭所有可能打开的底部弹出框
    try {
      if (Get.isBottomSheetOpen == true) {
        Get.back();
        debugPrint('🚪 关闭底部弹出框');
      }
    } catch (e) {
      debugPrint('⚠️ 关闭底部弹出框失败: $e');
    }
    
    // 释放签名控制器资源
    signatureController.dispose();
    super.onClose();
  }
}

/// 评审底部弹出框组件
class _ReviewBottomSheet extends StatelessWidget {
  final ShnebaoAssessmentDetialController controller;
  
  const _ReviewBottomSheet({
    required this.controller,
  });

  @override
  Widget build(BuildContext context) {
    return Container(
      constraints: BoxConstraints(
        maxHeight: MediaQuery.of(context).size.height * 0.85,
      ),
      decoration: const BoxDecoration(
        color: Colors.white,
        borderRadius: BorderRadius.only(
          topLeft: Radius.circular(20),
          topRight: Radius.circular(20),
        ),
      ),
      child: Column(
        mainAxisSize: MainAxisSize.min,
        children: [
          // 顶部指示器和标题
          _buildHeader(),
          
          // 内容区域
          Flexible(
            child: SingleChildScrollView(
              padding: const EdgeInsets.symmetric(horizontal: 20),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  // 项目信息
                  _buildProjectInfo(),
                  const SizedBox(height: 16),
                  
                  // 组长身份提示
                  _buildLeaderIndicator(),
                  const SizedBox(height: 16),
                  
                  // 审核意见输入框（仅组长可见）
                  Obx(() {
                    if (controller.isLeader.value) {
                      return Column(
                        children: [
                  _buildReviewOpinionInput(),
                  const SizedBox(height: 16),
                        ],
                      );
                    } else {
                      return const SizedBox.shrink();
                    }
                  }),
                  
                  // 签名图片上传
                  _buildSignatureUpload(),
                  const SizedBox(height: 16),
                  
                  // 错误信息显示
                  _buildErrorMessage(),
                  const SizedBox(height: 20),
                ],
              ),
            ),
          ),
          
          // 底部按钮
          _buildBottomButtons(),
        ],
      ),
    );
  }

  /// 构建头部
  Widget _buildHeader() {
    return Container(
      padding: const EdgeInsets.only(top: 8, bottom: 12),
      child: Column(
        children: [
          // 顶部指示器
          Container(
            width: 40,
            height: 4,
            decoration: BoxDecoration(
              color: Colors.grey.shade300,
              borderRadius: BorderRadius.circular(2),
            ),
          ),
          const SizedBox(height: 12),
          
          // 标题和关闭按钮
          Padding(
            padding: const EdgeInsets.symmetric(horizontal: 16),
            child: Row(
              children: [
                const Expanded(
                  child: Text(
                    '填写评审意见和签名',
                    style: TextStyle(
                      fontSize: 18,
                      fontWeight: FontWeight.bold,
                      color: Colors.black87,
                    ),
                  ),
                ),
                IconButton(
                  icon: Icon(Icons.close, size: 24, color: Colors.grey.shade600),
                  onPressed: () => Get.back(),
                  padding: EdgeInsets.zero,
                  constraints: const BoxConstraints(),
                  tooltip: '关闭',
                ),
              ],
            ),
          ),
        ],
      ),
    );
  }

  /// 构建项目信息
  Widget _buildProjectInfo() {
    return Obx(() {
      final project = controller.project.value;
      if (project == null) return const SizedBox.shrink();
      
      return Container(
        padding: const EdgeInsets.all(12),
        decoration: BoxDecoration(
          color: Colors.blue.shade50,
          borderRadius: BorderRadius.circular(8),
          border: Border.all(color: Colors.blue.shade200),
        ),
        child: Row(
          children: [
            Icon(Icons.assignment, color: Colors.blue.shade600, size: 20),
            const SizedBox(width: 8),
            Expanded(
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text(
                    project.projectName ?? '未知项目',
                    style: const TextStyle(
                      fontSize: 14,
                      fontWeight: FontWeight.w500,
                    ),
                    maxLines: 2,
                    overflow: TextOverflow.ellipsis,
                  ),
                  if (project.declareDepartment?.isNotEmpty == true && project.declareDepartment != 'null') ...[
                    const SizedBox(height: 2),
                    Text(
                      project.declareDepartment!,
                      style: TextStyle(
                        fontSize: 12,
                        color: Colors.grey.shade600,
                      ),
                    ),
                  ],
                ],
              ),
            ),
          ],
        ),
      );
    });
  }

  /// 构建组长身份提示
  Widget _buildLeaderIndicator() {
    return Obx(() {
      final isLeader = controller.isLeader.value;
      
      return Container(
        padding: const EdgeInsets.all(12),
        decoration: BoxDecoration(
          gradient: LinearGradient(
            colors: isLeader 
                ? [Colors.amber.shade50, Colors.amber.shade100]
                : [Colors.grey.shade50, Colors.grey.shade100],
          ),
          borderRadius: BorderRadius.circular(8),
          border: Border.all(
            color: isLeader ? Colors.amber.shade300 : Colors.grey.shade300,
          ),
        ),
        child: Row(
          children: [
            Icon(
              isLeader ? Icons.star : Icons.people,
              color: isLeader ? Colors.amber.shade700 : Colors.grey.shade600,
              size: 20,
            ),
            const SizedBox(width: 8),
            Expanded(
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text(
                    isLeader ? '您是评审组长' : '您是评审专家',
                    style: TextStyle(
                      fontSize: 14,
                      fontWeight: FontWeight.w600,
                      color: isLeader ? Colors.amber.shade900 : Colors.grey.shade800,
                    ),
                  ),
                  const SizedBox(height: 2),
                  Text(
                    isLeader 
                        ? '请填写统一的评审意见并签名确认'
                        : '请在组长填写意见后进行签名确认',
                    style: TextStyle(
                      fontSize: 12,
                      color: isLeader ? Colors.amber.shade800 : Colors.grey.shade600,
                    ),
                  ),
                ],
              ),
            ),
          ],
        ),
      );
    });
  }

  /// 构建审核意见输入框
  Widget _buildReviewOpinionInput() {
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        const Text(
          '审核意见 *',
          style: TextStyle(
            fontSize: 16,
            fontWeight: FontWeight.w500,
            color: Colors.black87,
          ),
        ),
        const SizedBox(height: 8),
        Container(
          decoration: BoxDecoration(
            borderRadius: BorderRadius.circular(8),
            border: Border.all(color: Colors.grey.shade300),
          ),
          child: TextField(
            maxLines: 4,
            onChanged: (value) => controller.reviewOpinion.value = value,
            decoration: InputDecoration(
              hintText: '请填写详细的审核意见...',
              hintStyle: TextStyle(color: Colors.grey.shade500),
              border: InputBorder.none,
              contentPadding: const EdgeInsets.all(12),
            ),
            style: const TextStyle(fontSize: 14),
          ),
        ),
      ],
    );
  }

  /// 构建手写签名
  Widget _buildSignatureUpload() {
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        Row(
          children: [
            const Text(
              '专家签名 *',
              style: TextStyle(
                fontSize: 16,
                fontWeight: FontWeight.w500,
                color: Colors.black87,
              ),
            ),
            const Spacer(),
            Obx(() {
              return controller.hasSignature.value
                  ? TextButton.icon(
                      onPressed: controller.onClearSignature,
                      icon: const Icon(Icons.clear, size: 16),
                      label: const Text('清除'),
                      style: TextButton.styleFrom(
                        foregroundColor: Colors.red.shade600,
                        padding: const EdgeInsets.symmetric(horizontal: 8),
                      ),
                    )
                  : const SizedBox.shrink();
            }),
          ],
        ),
        const SizedBox(height: 8),
        
        // 手写签名板
        Container(
          width: double.infinity,
          height: 150,
          decoration: BoxDecoration(
            borderRadius: BorderRadius.circular(8),
            border: Border.all(color: Colors.grey.shade300),
            color: Colors.white,
          ),
          child: ClipRRect(
            borderRadius: BorderRadius.circular(8),
            child: Signature(
              controller: controller.signatureController,
              backgroundColor: Colors.white,
            ),
          ),
        ),
        
        const SizedBox(height: 8),
        
        // 签名状态提示
        Obx(() {
          final hasSignature = controller.hasSignature.value;
          if (hasSignature) {
            return Container(
              padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
              decoration: BoxDecoration(
                color: Colors.blue.shade50,
                borderRadius: BorderRadius.circular(8),
                border: Border.all(color: Colors.blue.shade200),
              ),
              child: Row(
                children: [
                  Icon(Icons.check_circle_outline, color: Colors.blue.shade700, size: 18),
                  const SizedBox(width: 8),
                  Text(
                    '签名已完成，请选择评审结果提交',
                    style: TextStyle(
                      color: Colors.blue.shade700,
                      fontSize: 13,
                      fontWeight: FontWeight.w500,
                    ),
                  ),
                ],
              ),
            );
          } else {
            return Container(
              padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
              decoration: BoxDecoration(
                color: Colors.grey.shade100,
                borderRadius: BorderRadius.circular(8),
                border: Border.all(color: Colors.grey.shade300),
              ),
              child: Row(
                children: [
                  Icon(Icons.info_outline, color: Colors.grey.shade600, size: 18),
                  const SizedBox(width: 8),
                  Text(
                    '请在上方签名板中完成手写签名',
                    style: TextStyle(
                      color: Colors.grey.shade600,
                      fontSize: 13,
                ),
                  ),
                ],
              ),
            );
          }
        }),
      ],
    );
  }

  /// 构建错误信息
  Widget _buildErrorMessage() {
    return Obx(() {
      final errorMessage = controller.uploadErrorMessage.value;
      if (errorMessage.isEmpty) return const SizedBox.shrink();
      
      return Container(
        padding: const EdgeInsets.all(12),
        decoration: BoxDecoration(
          color: Colors.red.shade50,
          borderRadius: BorderRadius.circular(8),
          border: Border.all(color: Colors.red.shade200),
        ),
        child: Row(
          children: [
            Icon(Icons.error_outline, color: Colors.red.shade600, size: 16),
            const SizedBox(width: 8),
            Expanded(
              child: Text(
                errorMessage,
                style: TextStyle(
                  color: Colors.red.shade600,
                  fontSize: 12,
                ),
              ),
            ),
          ],
        ),
      );
    });
  }

  /// 构建底部按钮
  Widget _buildBottomButtons() {
    return Container(
      padding: const EdgeInsets.all(20),
      decoration: BoxDecoration(
        color: Colors.white,
        boxShadow: [
          BoxShadow(
            color: Colors.grey.shade200,
            offset: const Offset(0, -2),
            blurRadius: 8,
            spreadRadius: 0,
          ),
        ],
      ),
      child: SafeArea(
        child: Row(
          children: [
            // 评审拒绝按钮（仅组长可见）
            Obx(() {
              if (!controller.isLeader.value) {
                return const SizedBox.shrink();
              }
              
              return Expanded(
              child: Obx(() {
                final hasOpinion = controller.reviewOpinion.value.trim().isNotEmpty;
                final hasSignature = controller.hasSignature.value;
                final canSubmit = hasOpinion && hasSignature;
                
                return OutlinedButton.icon(
                  onPressed: canSubmit ? controller.onReviewReject : null,
                  icon: const Icon(Icons.close, size: 18),
                  label: const Text('评审拒绝'),
                  style: OutlinedButton.styleFrom(
                    padding: const EdgeInsets.symmetric(vertical: 12),
                    side: BorderSide(
                      color: canSubmit ? Colors.red.shade600 : Colors.grey.shade300,
                    ),
                    foregroundColor: Colors.red.shade600,
                    disabledForegroundColor: Colors.grey.shade400,
                  ),
                );
              }),
              );
            }),
            
            Obx(() {
              if (controller.isLeader.value) {
                return const SizedBox(width: 12);
              } else {
                return const SizedBox.shrink();
              }
            }),
            
            // 评审通过按钮（仅组长可见）/ 提交评审按钮（非组长）
            Expanded(
              child: Obx(() {
                final isLeader = controller.isLeader.value;
                final hasOpinion = controller.reviewOpinion.value.trim().isNotEmpty;
                final hasSignature = controller.hasSignature.value;
                
                if (isLeader) {
                  // 组长：显示评审通过按钮，需要评审意见 + 签名
                final canSubmit = hasOpinion && hasSignature;
                
                return ElevatedButton.icon(
                  onPressed: canSubmit ? controller.onReviewApprove : null,
                  icon: const Icon(Icons.check, size: 18),
                  label: const Text('评审通过'),
                  style: ElevatedButton.styleFrom(
                    padding: const EdgeInsets.symmetric(vertical: 12),
                    backgroundColor: Colors.green.shade600,
                    foregroundColor: Colors.white,
                    disabledBackgroundColor: Colors.grey.shade300,
                    disabledForegroundColor: Colors.grey.shade600,
                  ),
                );
                } else {
                  // 🔥 组员：只需要签名（评审意见由组长统一填写）
                  final canSubmit = hasSignature;
                  
                  return ElevatedButton.icon(
                    onPressed: canSubmit ? controller.onReviewApprove : null,
                    icon: const Icon(Icons.send, size: 18),
                    label: const Text('提交评审'),
                    style: ElevatedButton.styleFrom(
                      padding: const EdgeInsets.symmetric(vertical: 12),
                      backgroundColor: Colors.blue.shade600,
                      foregroundColor: Colors.white,
                      disabledBackgroundColor: Colors.grey.shade300,
                      disabledForegroundColor: Colors.grey.shade600,
                    ),
                  );
                }
              }),
            ),
          ],
        ),
      ),
    );
  }
}
